// src/services/vocabularyService.js
// 主服务：保留扩展功能，引用vocabularyApi的核心接口调用
import { vocabularyApi } from '@/views/subjects/english/pages/vocabulary-study/script/vocabulary-js/vocabularyMatching.js'; // 引用第一段代码
import { api } from '@/api/internal-api/internal-api';

/**
 * 词汇相关API服务封装
 * 主服务：保留扩展功能，核心接口调用复用vocabularyApi
 */
const vocabularyService = {
    /**
     * 获取所有词汇本列表（复用vocabularyApi的实现）
     * @returns {Promise<Array>} 词汇本列表
     */
    async getVocabBooks() {
        try {
            // 直接调用vocabularyApi的核心实现
            const books = await vocabularyApi.getVocabBooks();
            return books;
        } catch (error) {
            console.error('获取词汇本列表失败:', error);
            // 增强错误信息
            let errorMsg = '获取词汇本列表失败，请稍后重试';
            if (error.message.includes('404')) {
                errorMsg = '未找到词汇本资源';
            } else if (error.message.includes('500')) {
                errorMsg = '服务器内部错误，无法获取词汇本';
            } else if (error.message) {
                errorMsg = error.message;
            }
            throw new Error(errorMsg);
        }
    },

    /**
     * 根据词汇本ID获取单词列表（复用vocabularyApi的实现，增加数据转换）
     * @param {number} bookId - 词汇本ID
     * @returns {Promise<Array>} 标准化后的单词列表
     */
    async getWordsByBookId(bookId) {
        // 入参校验
        if (typeof bookId !== 'number' || isNaN(bookId) || bookId <= 0) {
            throw new Error('词汇本ID必须为有效的正整数');
        }

        try {
            // 调用vocabularyApi的核心接口
            const rawWords = await vocabularyApi.getWordsByBookId(bookId);

            // 主服务扩展：转换为更丰富的格式
            return rawWords
                .map(word => this.transformWordData(word, bookId))
                .filter(Boolean);
        } catch (error) {
            console.error(`获取词汇本${bookId}的单词失败：`, error);
            // 增强错误信息
            let errorMsg = '获取词汇本单词失败，请稍后重试';
            if (error.message.includes('404')) {
                errorMsg = '未找到指定的词汇本';
            } else if (error.message.includes('500')) {
                errorMsg = '服务器内部错误，请稍后重试';
            } else if (error.message) {
                errorMsg = error.message;
            }
            throw new Error(errorMsg);
        }
    },

    /**
     * 主服务独有功能：根据单词ID查询单个单词详情
     * @param {number} wordId - 单词ID
     * @returns {Promise<Object>} 单词详情对象
     */
    async getWordById(wordId) {
        if (typeof wordId !== 'number' || isNaN(wordId) || wordId <= 0) {
            throw new Error('单词ID必须为有效的正整数');
        }

        try {
            // 这里可以是独立接口，或从词汇本列表中筛选
            const response = await api.get(`${vocabularyApi.API_PREFIX}/bookss/${wordId}`);
            const rawWord = await response.data;
            return this.transformWordData(rawWord);
        } catch (error) {
            console.error(`查询单词ID=${wordId}失败:`, error);
            let errorMsg = '查询单词失败，请稍后重试';
            if (error.message.includes('404')) {
                errorMsg = `未找到ID为 ${wordId} 的单词`;
            }
            throw new Error(errorMsg);
        }
    },

    /**
     * 主服务扩展：转换单词数据格式（增强版）
     * @param {Object} rawWord - 原始单词数据
     * @param {number} [bookId] - 词汇本ID
     * @returns {Object} 增强后的单词对象
     */
    transformWordData(rawWord, bookId) {
        if (!rawWord || !rawWord.id || !rawWord.word) {
            console.warn('无效的单词数据:', rawWord);
            return null;
        }

        // 自动判断难度级别
        const getDifficulty = () => {
            const length = rawWord.word.length;
            if (length <= 4) return 'Beginner';
            if (length <= 7) return 'Intermediate';
            return 'Advanced';
        };

        return {
            // 保留vocabularyApi返回的基础字段
            id: rawWord.id,
            word: rawWord.word,
            pronunciation: rawWord.pronunciation,
            definition: rawWord.definition,
            example: rawWord.example,
            chinese: rawWord.chinese,

            // 主服务扩展字段
            wordId: rawWord.id, // 兼容不同命名
            partOfSpeech: this.mapPartOfSpeech(rawWord.category),
            difficulty: getDifficulty(),
            synonyms: rawWord.synonyms || [],
            bookId: bookId || null,
            isExpanded: false
        };
    },

    /**
     * 主服务扩展：映射词性
     * @param {string} category - 词性缩写
     * @returns {string} 标准化词性
     */
    mapPartOfSpeech(category) {
        if (!category) return 'unknown';
        const posMap = {
            'n': 'noun',
            'v': 'verb',
            'adj': 'adjective',
            'adv': 'adverb',
            'pron': 'pronoun',
            'prep': 'preposition',
            'conj': 'conjunction'
        };
        return posMap[category.toLowerCase()] || category;
    }
};

export default vocabularyService;